{
child = children->data;
- if (gtk_widget_get_visible (child->widget))
+ if (_gtk_widget_get_visible (child->widget))
{
*visible_children += 1;
if (child->expand || gtk_widget_compute_expand (child->widget, private->orientation))
{
child = children->data;
- if (!gtk_widget_get_visible (child->widget))
+ if (!_gtk_widget_get_visible (child->widget))
continue;
if (private->orientation == GTK_ORIENTATION_HORIZONTAL)
child = children->data;
/* If widget is not visible, skip it. */
- if (!gtk_widget_get_visible (child->widget))
+ if (!_gtk_widget_get_visible (child->widget))
continue;
/* If widget is packed differently skip it, but still increment i,
child = children->data;
/* If widget is not visible, skip it. */
- if (!gtk_widget_get_visible (child->widget))
+ if (!_gtk_widget_get_visible (child->widget))
continue;
/* If widget is packed differently skip it, but still increment i,
child = children->data;
if (child != priv->center &&
- gtk_widget_get_visible (child->widget))
+ _gtk_widget_get_visible (child->widget))
{
nvis[child->pack] += 1;
if (child->expand || gtk_widget_compute_expand (child->widget, priv->orientation))
child = children->data;
- if (!gtk_widget_get_visible (child->widget))
+ if (!_gtk_widget_get_visible (child->widget))
continue;
if (child == priv->center)
child = children->data;
/* If widget is not visible, skip it. */
- if (!gtk_widget_get_visible (child->widget))
+ if (!_gtk_widget_get_visible (child->widget))
continue;
/* Skip the center widget */
child = children->data;
/* If widget is not visible, skip it. */
- if (!gtk_widget_get_visible (child->widget))
+ if (!_gtk_widget_get_visible (child->widget))
continue;
/* Skip the center widget */
GtkBox *box = GTK_BOX (widget);
if (box->priv->center &&
- gtk_widget_get_visible (box->priv->center->widget))
+ _gtk_widget_get_visible (box->priv->center->widget))
gtk_box_size_allocate_with_center (widget, allocation);
else
gtk_box_size_allocate_no_center (widget, allocation);
{
CountingData *count = data;
- if (!gtk_widget_get_visible (widget))
+ if (!_gtk_widget_get_visible (widget))
return;
if (count->widget == widget)
path = _gtk_widget_create_path (GTK_WIDGET (container));
- if (gtk_widget_get_visible (child))
+ if (_gtk_widget_get_visible (child))
{
gint position;
for (list = children; list; list = list->next)
{
- if (!gtk_widget_get_visible (list->data))
+ if (!_gtk_widget_get_visible (list->data))
continue;
gtk_widget_path_append_for_widget (sibling_path, list->data);
g_return_val_if_fail (GTK_IS_BOX (box), NULL);
g_return_val_if_fail (GTK_IS_WIDGET (child), NULL);
- g_return_val_if_fail (gtk_widget_get_parent (child) == NULL, NULL);
+ g_return_val_if_fail (_gtk_widget_get_parent (child) == NULL, NULL);
child_info = g_new (GtkBoxChild, 1);
child_info->widget = child;
{
GtkBoxChild *child = children->data;
- if (gtk_widget_get_visible (child->widget))
+ if (_gtk_widget_get_visible (child->widget))
{
gint child_minimum, child_natural;
gint child_minimum_baseline = -1, child_natural_baseline = -1;
{
child = children->data;
- if (gtk_widget_get_visible (child->widget))
+ if (_gtk_widget_get_visible (child->widget))
{
if (private->orientation == GTK_ORIENTATION_HORIZONTAL)
gtk_widget_get_preferred_width (child->widget,
child = children->data;
/* If widget is not visible, skip it. */
- if (!gtk_widget_get_visible (child->widget))
+ if (!_gtk_widget_get_visible (child->widget))
continue;
/* If widget is packed differently skip it, but still increment i,
{
GtkBoxChild *child = children->data;
- if (gtk_widget_get_visible (child->widget))
+ if (_gtk_widget_get_visible (child->widget))
{
if (private->orientation == GTK_ORIENTATION_HORIZONTAL)
priv->children = g_list_insert_before (priv->children, new_link, child_info);
gtk_widget_child_notify (child, "position");
- if (gtk_widget_get_visible (child) &&
- gtk_widget_get_visible (GTK_WIDGET (box)))
+ if (_gtk_widget_get_visible (child) &&
+ _gtk_widget_get_visible (GTK_WIDGET (box)))
{
gtk_box_invalidate_order (box);
gtk_widget_queue_resize (child);
gtk_box_invalidate_order (box);
}
- if (gtk_widget_get_visible (child)
- && gtk_widget_get_visible (GTK_WIDGET (box)))
+ if (_gtk_widget_get_visible (child) &&
+ _gtk_widget_get_visible (GTK_WIDGET (box)))
gtk_widget_queue_resize (child);
}
gtk_widget_thaw_child_notify (child);
box_child_visibility_notify_cb,
box);
- was_visible = gtk_widget_get_visible (widget);
+ was_visible = _gtk_widget_get_visible (widget);
gtk_widget_unparent (widget);
priv->children = g_list_remove_link (priv->children, children);
GTK_BUILDER_WARN_INVALID_CHILD_TYPE (buildable, type);
}
else if (GTK_IS_WIDGET (child) &&
- gtk_widget_get_parent (GTK_WIDGET (child)) == NULL)
+ _gtk_widget_get_parent (GTK_WIDGET (child)) == NULL)
{
gtk_container_add (GTK_CONTAINER (buildable), GTK_WIDGET (child));
}
GValue gvalue = G_VALUE_INIT;
GError *error = NULL;
- if (gtk_widget_get_parent (child) != (GtkWidget *)container &&
+ if (_gtk_widget_get_parent (child) != (GtkWidget *)container &&
!GTK_IS_ASSISTANT (container) &&
!GTK_IS_ACTION_BAR (container) &&
!GTK_IS_POPOVER_MENU (container))
{
g_return_if_fail (GTK_IS_CONTAINER (container));
g_return_if_fail (GTK_IS_WIDGET (widget));
- g_return_if_fail (gtk_widget_get_parent (widget) == NULL);
+ g_return_if_fail (_gtk_widget_get_parent (widget) == NULL);
g_object_ref (container);
g_object_ref (widget);
gtk_widget_freeze_child_notify (widget);
g_signal_emit (container, container_signals[ADD], 0, widget);
- if (gtk_widget_get_parent (widget))
+ if (_gtk_widget_get_parent (widget))
{
va_list var_args;
g_object_notify_by_pspec (G_OBJECT (container), container_props[PROP_BORDER_WIDTH]);
- if (gtk_widget_get_realized (GTK_WIDGET (container)))
+ if (_gtk_widget_get_realized (GTK_WIDGET (container)))
gtk_widget_queue_resize (GTK_WIDGET (container));
}
}
g_return_if_fail (GTK_IS_CONTAINER (container));
g_return_if_fail (GTK_IS_WIDGET (widget));
- parent = gtk_widget_get_parent (widget);
+ parent = _gtk_widget_get_parent (widget);
if (parent != NULL)
{
{
g_return_if_fail (GTK_IS_CONTAINER (container));
g_return_if_fail (GTK_IS_WIDGET (widget));
- g_return_if_fail (gtk_widget_get_parent (widget) == GTK_WIDGET (container) ||
+ g_return_if_fail (_gtk_widget_get_parent (widget) == GTK_WIDGET (container) ||
GTK_IS_ASSISTANT (container) ||
GTK_IS_ACTION_BAR (container) ||
GTK_IS_POPOVER_MENU (container));
GtkResizeMode resize_mode)
{
GtkContainerPrivate *priv;
+ GtkWidget *widget = (GtkWidget *)container;
g_return_if_fail (GTK_IS_CONTAINER (container));
g_return_if_fail (resize_mode <= GTK_RESIZE_IMMEDIATE);
priv = container->priv;
- if (gtk_widget_is_toplevel (GTK_WIDGET (container)) &&
+ if (_gtk_widget_is_toplevel (widget) &&
resize_mode == GTK_RESIZE_PARENT)
{
resize_mode = GTK_RESIZE_QUEUE;
{
priv->resize_mode = resize_mode;
- gtk_widget_queue_resize (GTK_WIDGET (container));
+ gtk_widget_queue_resize (widget);
g_object_notify_by_pspec (G_OBJECT (container), container_props[PROP_RESIZE_MODE]);
}
}
widget = GTK_WIDGET (container);
- if (gtk_widget_get_visible (widget) &&
- (gtk_widget_is_toplevel (widget) ||
- gtk_widget_get_realized (widget)))
+ if (_gtk_widget_get_visible (widget) &&
+ (_gtk_widget_is_toplevel (widget) ||
+ _gtk_widget_get_realized (widget)))
{
switch (container->priv->resize_mode)
{
{
GtkWidget *widget;
- g_return_if_fail (GTK_IS_CONTAINER (container));
-
- widget = GTK_WIDGET (container);
+ widget = (GtkWidget*)container;
do
{
_gtk_size_request_cache_clear (_gtk_widget_peek_request_cache (widget));
G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
- if (GTK_IS_RESIZE_CONTAINER (widget))
+ if (((GtkContainer*)widget)->priv->resize_mode != GTK_RESIZE_PARENT)
break;
G_GNUC_END_IGNORE_DEPRECATIONS;
- widget = gtk_widget_get_parent (widget);
+ widget = _gtk_widget_get_parent (widget);
}
while (widget);
if (widget && !invalidate_only)
- gtk_container_queue_resize_handler (GTK_CONTAINER (widget));
+ gtk_container_queue_resize_handler ((GtkContainer*)widget);
}
void
g_return_val_if_fail (GTK_IS_CONTAINER (container), NULL);
g_return_val_if_fail (GTK_IS_WIDGET (child), NULL);
- g_return_val_if_fail (gtk_widget_get_parent (child) == GTK_WIDGET (container), NULL);
+ g_return_val_if_fail (_gtk_widget_get_parent (child) == GTK_WIDGET (container), NULL);
g_object_get (child, "composite-child", &composite_child, NULL);
if (composite_child)
GtkStyleContext *context;
GtkWidgetPath *path;
GList *classes;
+ GtkWidget *widget = (GtkWidget *)container;
- context = gtk_widget_get_style_context (GTK_WIDGET (container));
- path = _gtk_widget_create_path (GTK_WIDGET (container));
+ context = _gtk_widget_get_style_context (widget);
+ path = _gtk_widget_create_path (widget);
/* Copy any permanent classes to the path */
classes = gtk_style_context_list_classes (context);
{
GtkWidget *parent;
- parent = gtk_widget_get_parent (widget);
+ parent = _gtk_widget_get_parent (widget);
if (parent && (gtk_container_get_focus_child (GTK_CONTAINER (parent)) != widget))
goto next;
GdkRectangle *old_focus_rect)
{
GtkWidget *widget = GTK_WIDGET (container);
- GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
+ GtkWidget *toplevel = _gtk_widget_get_toplevel (widget);
GtkWidget *old_focus;
if (GTK_IS_WINDOW (toplevel))
while (children)
{
- if (gtk_widget_get_realized (children->data))
+ if (_gtk_widget_get_realized (children->data))
visible_children = g_list_prepend (visible_children, children->data);
children = children->next;
}
gtk_container_map_child (GtkWidget *child,
gpointer client_data)
{
- if (gtk_widget_get_visible (child) &&
- gtk_widget_get_child_visible (child) &&
- !gtk_widget_get_mapped (child))
+ if (_gtk_widget_get_visible (child) &&
+ _gtk_widget_get_child_visible (child) &&
+ !_gtk_widget_get_mapped (child))
gtk_widget_map (child);
}
g_return_if_fail (GTK_IS_WIDGET (child));
g_return_if_fail (cr != NULL);
- g_assert (gtk_widget_get_parent (child) == GTK_WIDGET (container));
+ g_assert (_gtk_widget_get_parent (child) == GTK_WIDGET (container));
if (!gtk_container_should_propagate_draw (container, child, cr))
return;
g_return_val_if_fail (GTK_IS_CONTAINER (container), NULL);
g_return_val_if_fail (GTK_IS_WIDGET (child), NULL);
- g_return_val_if_fail (container == (GtkContainer *) gtk_widget_get_parent (child), NULL);
+ g_return_val_if_fail (container == (GtkContainer *) _gtk_widget_get_parent (child), NULL);
path = GTK_CONTAINER_GET_CLASS (container)->get_path_for_child (container, child);
if (gtk_widget_path_get_object_type (path) != G_OBJECT_TYPE (child))
g_assert (i == G_N_ELEMENTS (funcs));
}
- parent = gtk_widget_get_parent (widget);
+ parent = _gtk_widget_get_parent (widget);
if (parent == NULL)
return FALSE;
result = g_object_new (GTK_TYPE_CSS_WIDGET_NODE, NULL);
result->widget = widget;
gtk_css_node_set_visible (GTK_CSS_NODE (result),
- gtk_widget_get_visible (widget));
+ _gtk_widget_get_visible (widget));
return GTK_CSS_NODE (result);
}
break;
}
- if (gtk_widget_get_visible (child) &&
- gtk_widget_get_visible (GTK_WIDGET (grid)))
+ if (_gtk_widget_get_visible (child) &&
+ _gtk_widget_get_visible (GTK_WIDGET (grid)))
gtk_widget_queue_resize (child);
}
if (grid_child->widget == child)
{
- gboolean was_visible = gtk_widget_get_visible (child);
+ gboolean was_visible = _gtk_widget_get_visible (child);
gtk_widget_unparent (child);
g_slice_free (GtkGridChild, grid_child);
- if (was_visible && gtk_widget_get_visible (GTK_WIDGET (grid)))
+ if (was_visible && _gtk_widget_get_visible (GTK_WIDGET (grid)))
gtk_widget_queue_resize (GTK_WIDGET (grid));
break;
{
child = list->data;
- if (!gtk_widget_get_visible (child->widget))
+ if (!_gtk_widget_get_visible (child->widget))
continue;
attach = &child->attach[orientation];
{
child = list->data;
- if (!gtk_widget_get_visible (child->widget))
+ if (!_gtk_widget_get_visible (child->widget))
continue;
attach = &child->attach[orientation];
{
child = list->data;
- if (!gtk_widget_get_visible (child->widget))
+ if (!_gtk_widget_get_visible (child->widget))
continue;
attach = &child->attach[orientation];
{
child = list->data;
- if (!gtk_widget_get_visible (child->widget))
+ if (!_gtk_widget_get_visible (child->widget))
continue;
attach = &child->attach[orientation];
{
child = list->data;
- if (!gtk_widget_get_visible (child->widget))
+ if (!_gtk_widget_get_visible (child->widget))
continue;
allocate_child (request, GTK_ORIENTATION_HORIZONTAL, child, &x, &width, &ignore);
{
g_return_if_fail (GTK_IS_GRID (grid));
g_return_if_fail (GTK_IS_WIDGET (child));
- g_return_if_fail (gtk_widget_get_parent (child) == NULL);
+ g_return_if_fail (_gtk_widget_get_parent (child) == NULL);
g_return_if_fail (width > 0);
g_return_if_fail (height > 0);
g_return_if_fail (GTK_IS_GRID (grid));
g_return_if_fail (GTK_IS_WIDGET (child));
- g_return_if_fail (gtk_widget_get_parent (child) == NULL);
- g_return_if_fail (sibling == NULL || gtk_widget_get_parent (sibling) == (GtkWidget*)grid);
+ g_return_if_fail (_gtk_widget_get_parent (child) == NULL);
+ g_return_if_fail (sibling == NULL || _gtk_widget_get_parent (sibling) == (GtkWidget*)grid);
g_return_if_fail (width > 0);
g_return_if_fail (height > 0);
g_return_if_fail (GTK_IS_GRID (grid));
g_return_if_fail (GTK_IS_WIDGET (sibling));
- g_return_if_fail (gtk_widget_get_parent (sibling) == (GtkWidget*)grid);
+ g_return_if_fail (_gtk_widget_get_parent (sibling) == (GtkWidget*)grid);
child = find_grid_child (grid, sibling);
{
COLUMNS (priv)->homogeneous = homogeneous;
- if (gtk_widget_get_visible (GTK_WIDGET (grid)))
+ if (_gtk_widget_get_visible (GTK_WIDGET (grid)))
gtk_widget_queue_resize (GTK_WIDGET (grid));
g_object_notify_by_pspec (G_OBJECT (grid), obj_properties [PROP_ROW_HOMOGENEOUS]);
{
ROWS (priv)->homogeneous = homogeneous;
- if (gtk_widget_get_visible (GTK_WIDGET (grid)))
+ if (_gtk_widget_get_visible (GTK_WIDGET (grid)))
gtk_widget_queue_resize (GTK_WIDGET (grid));
g_object_notify_by_pspec (G_OBJECT (grid), obj_properties [PROP_COLUMN_HOMOGENEOUS]);
{
COLUMNS (priv)->spacing = spacing;
- if (gtk_widget_get_visible (GTK_WIDGET (grid)))
+ if (_gtk_widget_get_visible (GTK_WIDGET (grid)))
gtk_widget_queue_resize (GTK_WIDGET (grid));
g_object_notify_by_pspec (G_OBJECT (grid), obj_properties [PROP_ROW_SPACING]);
{
ROWS (priv)->spacing = spacing;
- if (gtk_widget_get_visible (GTK_WIDGET (grid)))
+ if (_gtk_widget_get_visible (GTK_WIDGET (grid)))
gtk_widget_queue_resize (GTK_WIDGET (grid));
g_object_notify_by_pspec (G_OBJECT (grid), obj_properties [PROP_COLUMN_SPACING]);
{
props->baseline_position = pos;
- if (gtk_widget_get_visible (GTK_WIDGET (grid)))
+ if (_gtk_widget_get_visible (GTK_WIDGET (grid)))
gtk_widget_queue_resize (GTK_WIDGET (grid));
}
}
{
priv->baseline_row = row;
- if (gtk_widget_get_visible (GTK_WIDGET (grid)))
+ if (_gtk_widget_get_visible (GTK_WIDGET (grid)))
gtk_widget_queue_resize (GTK_WIDGET (grid));
g_object_notify (G_OBJECT (grid), "baseline-row");
}
_gtk_widget_set_alloc_needed (widget, TRUE);
_gtk_size_request_cache_clear (_gtk_widget_peek_request_cache (widget));
- container = gtk_widget_get_parent (widget);
+ container = _gtk_widget_get_parent (widget);
if (!container &&
- gtk_widget_is_toplevel (widget) && GTK_IS_CONTAINER (widget))
+ _gtk_widget_is_toplevel (widget) && GTK_IS_CONTAINER (widget))
container = widget;
if (container)
if (widget == parent && !check_siblings)
{
real_queue_resize (widget, flags);
- parent = gtk_widget_get_parent (parent);
+ parent = _gtk_widget_get_parent (parent);
continue;
}
if (widget == parent)
real_queue_resize (widget, flags);
- parent = gtk_widget_get_parent (parent);
+ parent = _gtk_widget_get_parent (parent);
continue;
}
g_hash_table_destroy (widgets);
- parent = gtk_widget_get_parent (parent);
+ parent = _gtk_widget_get_parent (parent);
}
}
gpointer key;
gint min_result = 0, nat_result = 0;
- if (!gtk_widget_get_visible (widget) && !gtk_widget_is_toplevel (widget))
+ if (!_gtk_widget_get_visible (widget) && !_gtk_widget_is_toplevel (widget))
{
if (minimum)
*minimum = 0;
item;
item = gtk_style_cascade_iter_next (cascade, &iter))
{
- if (GTK_IS_STYLE_PROVIDER_PRIVATE (item))
+ GtkStyleProviderPrivate *sp = (GtkStyleProviderPrivate*)item;
+ if (GTK_IS_STYLE_PROVIDER_PRIVATE (sp))
{
- _gtk_style_provider_private_lookup (GTK_STYLE_PROVIDER_PRIVATE (item),
- matcher,
- lookup,
+ _gtk_style_provider_private_lookup (sp, matcher, lookup,
change ? &iter_change : NULL);
if (change)
*change |= iter_change;
#include "gtkselectionprivate.h"
#include "gtksettingsprivate.h"
#include "gtksizegroup-private.h"
-#include "gtksizerequestcacheprivate.h"
#include "gtkwidget.h"
#include "gtkwidgetprivate.h"
#include "gtkwindowprivate.h"
#define WIDGET_CLASS(w) GTK_WIDGET_GET_CLASS (w)
-#define GTK_STATE_FLAGS_BITS 12
-
typedef struct {
gchar *name; /* Name of the template automatic child */
gboolean internal_child; /* Whether the automatic widget should be exported as an <internal-child> */
guint sequence_state_changed_id;
} EventControllerData;
-struct _GtkWidgetPrivate
-{
- /* The state of the widget. Needs to be able to hold all GtkStateFlags bits
- * (defined in "gtkenums.h").
- */
- guint state_flags : GTK_STATE_FLAGS_BITS;
-
- guint direction : 2;
-
- guint in_destruction : 1;
- guint toplevel : 1;
- guint anchored : 1;
- guint composite_child : 1;
- guint no_window : 1;
- guint realized : 1;
- guint mapped : 1;
- guint visible : 1;
- guint sensitive : 1;
- guint can_focus : 1;
- guint has_focus : 1;
- guint can_default : 1;
- guint has_default : 1;
- guint receives_default : 1;
- guint has_grab : 1;
- guint shadowed : 1;
- guint style_update_pending : 1;
- guint app_paintable : 1;
- guint double_buffered : 1;
- guint redraw_on_alloc : 1;
- guint no_show_all : 1;
- guint child_visible : 1;
- guint multidevice : 1;
- guint has_shape_mask : 1;
- guint in_reparent : 1;
-
- /* Queue-resize related flags */
- guint alloc_needed : 1;
-
- /* Expand-related flags */
- guint need_compute_expand : 1; /* Need to recompute computed_[hv]_expand */
- guint computed_hexpand : 1; /* computed results (composite of child flags) */
- guint computed_vexpand : 1;
- guint hexpand : 1; /* application-forced expand */
- guint vexpand : 1;
- guint hexpand_set : 1; /* whether to use application-forced */
- guint vexpand_set : 1; /* instead of computing from children */
-
- /* SizeGroup related flags */
- guint have_size_groups : 1;
-
- guint8 alpha;
- guint8 user_alpha;
-
- /* The widget's name. If the widget does not have a name
- * (the name is NULL), then its name (as returned by
- * "gtk_widget_get_name") is its class's name.
- * Among other things, the widget name is used to determine
- * the style to use for a widget.
- */
- gchar *name;
-
- /* The list of attached windows to this widget.
- * We keep a list in order to call reset_style to all of them,
- * recursively. */
- GList *attached_windows;
-
- /* The style for the widget. The style contains the
- * colors the widget should be drawn in for each state
- * along with graphics contexts used to draw with and
- * the font to use for text.
- */
- GtkStyle *style;
- GtkCssNode *cssnode;
- GtkStyleContext *context;
-
- /* Widget's path for styling */
- GtkWidgetPath *path;
-
- /* The widget's allocated size */
- GtkAllocation allocation;
- gint allocated_baseline;
- GtkAllocation clip;
-
- /* The widget's requested sizes */
- SizeRequestCache requests;
-
- /* actions attached to this or any parent widget */
- GtkActionMuxer *muxer;
-
- /* The widget's window or its parent window if it does
- * not have a window. (Which will be indicated by the
- * no_window field being set).
- */
- GdkWindow *window;
- GList *registered_windows;
-
- /* The widget's parent */
- GtkWidget *parent;
-
- /* Animations and other things to update on clock ticks */
- GList *tick_callbacks;
- guint clock_tick_id;
-
- /* A hash by GType key, containing hash tables by widget name
- */
- GHashTable *auto_children;
-
-#ifdef G_ENABLE_DEBUG
- /* Number of gtk_widget_push_verify_invariants () */
- guint verifying_invariants_count;
-#endif /* G_ENABLE_DEBUG */
-
- GList *event_controllers;
-
- cairo_font_options_t *font_options;
- PangoFontMap *font_map;
-};
-
struct _GtkWidgetClassPrivate
{
GtkWidgetTemplate *template;
G_GNUC_END_IGNORE_DEPRECATIONS;
break;
case PROP_EVENTS:
- if (!gtk_widget_get_realized (widget) && gtk_widget_get_has_window (widget))
+ if (!_gtk_widget_get_realized (widget) && gtk_widget_get_has_window (widget))
gtk_widget_set_events (widget, g_value_get_flags (value));
break;
case PROP_NO_SHOW_ALL:
tmp = (tooltip_window != NULL || tooltip_markup != NULL);
gtk_widget_real_set_has_tooltip (widget, tmp, FALSE);
- if (gtk_widget_get_visible (widget))
+ if (_gtk_widget_get_visible (widget))
gtk_widget_queue_tooltip_query (widget);
break;
case PROP_TOOLTIP_TEXT:
tmp = (tooltip_window != NULL || tooltip_markup != NULL);
gtk_widget_real_set_has_tooltip (widget, tmp, FALSE);
- if (gtk_widget_get_visible (widget))
+ if (_gtk_widget_get_visible (widget))
gtk_widget_queue_tooltip_query (widget);
break;
case PROP_DOUBLE_BUFFERED:
}
break;
case PROP_VISIBLE:
- g_value_set_boolean (value, gtk_widget_get_visible (widget));
+ g_value_set_boolean (value, _gtk_widget_get_visible (widget));
break;
case PROP_SENSITIVE:
g_value_set_boolean (value, gtk_widget_get_sensitive (widget));
press->any.send_event = TRUE;
next_child = event_widget;
- parent = gtk_widget_get_parent (next_child);
+ parent = _gtk_widget_get_parent (next_child);
while (parent != widget)
{
next_child = parent;
- parent = gtk_widget_get_parent (parent);
+ parent = _gtk_widget_get_parent (parent);
}
/* Perform propagation state starting from the next child in the chain */
g_object_freeze_notify (G_OBJECT (widget));
nqueue = g_object_notify_queue_freeze (G_OBJECT (widget), _gtk_widget_child_property_notify_context);
- toplevel = gtk_widget_get_toplevel (widget);
- if (gtk_widget_is_toplevel (toplevel))
+ toplevel = _gtk_widget_get_toplevel (widget);
+ if (_gtk_widget_is_toplevel (toplevel))
_gtk_window_unset_focus_and_default (GTK_WINDOW (toplevel), widget);
if (gtk_container_get_focus_child (GTK_CONTAINER (priv->parent)) == widget)
priv->allocation.width = 1;
priv->allocation.height = 1;
- if (gtk_widget_get_realized (widget))
+ if (_gtk_widget_get_realized (widget))
{
if (priv->in_reparent)
gtk_widget_unmap (widget);
* child was expand=TRUE and could therefore
* be forcing it to.
*/
- if (gtk_widget_get_visible (widget) &&
+ if (_gtk_widget_get_visible (widget) &&
(priv->need_compute_expand ||
priv->computed_hexpand ||
priv->computed_vexpand))
{
g_return_if_fail (GTK_IS_WIDGET (widget));
- if (!gtk_widget_get_visible (widget))
+ if (!_gtk_widget_get_visible (widget))
{
g_object_ref (widget);
gtk_widget_push_verify_invariants (widget);
- if (!gtk_widget_is_toplevel (widget))
+ if (!_gtk_widget_is_toplevel (widget))
gtk_widget_queue_resize (widget);
/* see comment in set_parent() for why this should and can be
{
GtkWidgetPrivate *priv = widget->priv;
- if (!gtk_widget_get_visible (widget))
+ if (!_gtk_widget_get_visible (widget))
{
priv->visible = TRUE;
if (priv->parent &&
- gtk_widget_get_mapped (priv->parent) &&
- gtk_widget_get_child_visible (widget) &&
- !gtk_widget_get_mapped (widget))
+ _gtk_widget_get_mapped (priv->parent) &&
+ _gtk_widget_get_child_visible (widget) &&
+ !_gtk_widget_get_mapped (widget))
gtk_widget_map (widget);
}
}
g_return_if_fail (GTK_IS_WIDGET (widget));
/* make sure we will get event */
- if (!gtk_widget_get_mapped (widget) &&
- gtk_widget_is_toplevel (widget))
+ if (!_gtk_widget_get_mapped (widget) &&
+ _gtk_widget_is_toplevel (widget))
{
gtk_widget_show (widget);
{
g_return_if_fail (GTK_IS_WIDGET (widget));
- if (gtk_widget_get_visible (widget))
+ if (_gtk_widget_get_visible (widget))
{
- GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
+ GtkWidget *toplevel = _gtk_widget_get_toplevel (widget);
g_object_ref (widget);
gtk_widget_push_verify_invariants (widget);
- if (toplevel != widget && gtk_widget_is_toplevel (toplevel))
+ if (toplevel != widget && _gtk_widget_is_toplevel (toplevel))
_gtk_window_unset_focus_and_default (GTK_WINDOW (toplevel), widget);
/* a parent may now be expand=FALSE since we're hidden. */
gtk_css_node_set_visible (widget->priv->cssnode, FALSE);
g_signal_emit (widget, widget_signals[HIDE], 0);
- if (!gtk_widget_is_toplevel (widget))
+ if (!_gtk_widget_is_toplevel (widget))
gtk_widget_queue_resize (widget);
g_object_notify_by_pspec (G_OBJECT (widget), widget_props[PROP_VISIBLE]);
static void
gtk_widget_real_hide (GtkWidget *widget)
{
- if (gtk_widget_get_visible (widget))
+ if (_gtk_widget_get_visible (widget))
{
widget->priv->visible = FALSE;
- if (gtk_widget_get_mapped (widget))
+ if (_gtk_widget_get_mapped (widget))
gtk_widget_unmap (widget);
}
}
GtkWidgetPrivate *priv;
g_return_if_fail (GTK_IS_WIDGET (widget));
- g_return_if_fail (gtk_widget_get_visible (widget));
- g_return_if_fail (gtk_widget_get_child_visible (widget));
+ g_return_if_fail (_gtk_widget_get_visible (widget));
+ g_return_if_fail (_gtk_widget_get_child_visible (widget));
priv = widget->priv;
- if (!gtk_widget_get_mapped (widget))
+ if (!_gtk_widget_get_mapped (widget))
{
gtk_widget_push_verify_invariants (widget);
- if (!gtk_widget_get_realized (widget))
+ if (!_gtk_widget_get_realized (widget))
gtk_widget_realize (widget);
g_signal_emit (widget, widget_signals[MAP], 0);
priv = widget->priv;
- if (gtk_widget_get_mapped (widget))
+ if (_gtk_widget_get_mapped (widget))
{
g_object_ref (widget);
gtk_widget_push_verify_invariants (widget);
priv = widget->priv;
- if (!gtk_widget_get_realized (widget))
+ if (!_gtk_widget_get_realized (widget))
{
gtk_widget_push_verify_invariants (widget);
*/
if (priv->parent == NULL &&
- !gtk_widget_is_toplevel (widget))
+ !_gtk_widget_is_toplevel (widget))
g_warning ("Calling gtk_widget_realize() on a widget that isn't "
"inside a toplevel window is not going to work very well. "
"Widgets must be inside a toplevel container before realizing them.");
- if (priv->parent && !gtk_widget_get_realized (priv->parent))
+ if (priv->parent && !_gtk_widget_get_realized (priv->parent))
gtk_widget_realize (priv->parent);
G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
if (g_object_get_qdata (G_OBJECT (widget), quark_input_shape_info))
gtk_widget_input_shape_combine_region (widget, NULL);
- if (gtk_widget_get_realized (widget))
+ if (_gtk_widget_get_realized (widget))
{
if (widget->priv->mapped)
gtk_widget_unmap (widget);
g_return_if_fail (GTK_IS_WIDGET (widget));
- if (!gtk_widget_get_realized (widget))
+ if (!_gtk_widget_get_realized (widget))
return;
/* Just return if the widget or one of its ancestors isn't mapped */
for (w = widget; w != NULL; w = w->priv->parent)
- if (!gtk_widget_get_mapped (w))
+ if (!_gtk_widget_get_mapped (w))
return;
WIDGET_CLASS (widget)->queue_draw_region (widget, region);
{
g_return_if_fail (GTK_IS_WIDGET (widget));
- if (gtk_widget_get_realized (widget))
+ if (_gtk_widget_get_realized (widget))
gtk_widget_queue_draw (widget);
_gtk_size_group_queue_resize (widget, 0);
* hierarchy anyways, but should squash any funny business with
* reparenting windows and widgets.
*/
- GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
+ GtkWidget *toplevel = _gtk_widget_get_toplevel (widget);
GdkWindow *window = gtk_widget_get_window (toplevel);
g_assert (window != NULL);
* modified by this call.
*/
static void
-gtk_widget_invalidate_widget_windows (GtkWidget *widget,
+gtk_widget_invalidate_widget_windows (GtkWidget *widget,
cairo_region_t *region)
{
GtkWidgetPrivate *priv = widget->priv;
- if (!gtk_widget_get_realized (widget))
+ if (!_gtk_widget_get_realized (widget))
return;
if (gtk_widget_get_has_window (widget) && priv->parent)
g_return_if_fail (GTK_IS_WIDGET (widget));
- if (!priv->visible && !gtk_widget_is_toplevel (widget))
+ if (!priv->visible && !_gtk_widget_is_toplevel (widget))
return;
gtk_widget_push_verify_invariants (widget);
while (parent)
{
depth++;
- parent = gtk_widget_get_parent (parent);
+ parent = _gtk_widget_get_parent (parent);
}
name = g_type_name (G_OBJECT_TYPE (G_OBJECT (widget)));
position_changed |= (old_clip.x != priv->clip.x ||
old_clip.y != priv->clip.y);
- if (gtk_widget_get_mapped (widget) && priv->redraw_on_alloc)
+ if (_gtk_widget_get_mapped (widget) && priv->redraw_on_alloc)
{
if (!gtk_widget_get_has_window (widget) && position_changed)
{
}
if ((size_changed || position_changed || baseline_changed) && priv->parent &&
- gtk_widget_get_realized (priv->parent) && _gtk_container_get_reallocate_redraws (GTK_CONTAINER (priv->parent)))
+ _gtk_widget_get_realized (priv->parent) && _gtk_container_get_reallocate_redraws (GTK_CONTAINER (priv->parent)))
{
cairo_region_t *invalidate = cairo_region_create_rectangle (&priv->parent->priv->clip);
gtk_widget_invalidate_widget_windows (priv->parent, invalidate);
g_return_val_if_fail (GTK_IS_WIDGET (dest_widget), FALSE);
ancestor = gtk_widget_common_ancestor (src_widget, dest_widget);
- if (!ancestor || !gtk_widget_get_realized (src_widget) || !gtk_widget_get_realized (dest_widget))
+ if (!ancestor || !_gtk_widget_get_realized (src_widget) || !_gtk_widget_get_realized (dest_widget))
return FALSE;
/* Translate from allocation relative to window relative */
gtk_widget_set_allocation (widget, allocation);
- if (gtk_widget_get_realized (widget) &&
+ if (_gtk_widget_get_realized (widget) &&
gtk_widget_get_has_window (widget))
{
gdk_window_move_resize (priv->window,
push_group =
widget->priv->alpha != 255 &&
- (!gtk_widget_is_toplevel (widget) ||
+ (!_gtk_widget_is_toplevel (widget) ||
gtk_widget_get_visual (widget) == gdk_screen_get_rgba_visual (gtk_widget_get_screen (widget)));
if (push_group)
}
#define WIDGET_REALIZED_FOR_EVENT(widget, event) \
- (event->type == GDK_FOCUS_CHANGE || gtk_widget_get_realized(widget))
+ (event->type == GDK_FOCUS_CHANGE || _gtk_widget_get_realized(widget))
/**
* gtk_widget_event:
cairo_t *cr;
g_return_val_if_fail (GTK_IS_WIDGET (widget), TRUE);
- g_return_val_if_fail (gtk_widget_get_realized (widget), TRUE);
+ g_return_val_if_fail (_gtk_widget_get_realized (widget), TRUE);
g_return_val_if_fail (event != NULL, TRUE);
g_return_val_if_fail (event->type == GDK_EXPOSE, TRUE);
* the widget as we reparent it. if so we set a flag so
* that gtk_widget_unparent doesn't unrealize widget
*/
- if (gtk_widget_get_realized (widget) && gtk_widget_get_realized (new_parent))
+ if (_gtk_widget_get_realized (widget) && _gtk_widget_get_realized (new_parent))
priv->in_reparent = TRUE;
g_object_ref (widget);
* is the focus widget's parent, since containers above that will
* be set by the next loop.
*/
- toplevel = gtk_widget_get_toplevel (focus_widget);
- if (gtk_widget_is_toplevel (toplevel) && GTK_IS_WINDOW (toplevel))
+ toplevel = _gtk_widget_get_toplevel (focus_widget);
+ if (_gtk_widget_is_toplevel (toplevel) && GTK_IS_WINDOW (toplevel))
{
widget = gtk_window_get_focus (GTK_WINDOW (toplevel));
gtk_widget_real_move_focus (GtkWidget *widget,
GtkDirectionType direction)
{
- GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
+ GtkWidget *toplevel = _gtk_widget_get_toplevel (widget);
if (widget != toplevel && GTK_IS_WINDOW (toplevel))
{
{
GtkWidget *toplevel;
- toplevel = gtk_widget_get_toplevel (widget);
+ toplevel = _gtk_widget_get_toplevel (widget);
if (GTK_IS_WINDOW (toplevel))
draw_focus = gtk_window_get_focus_visible (GTK_WINDOW (toplevel));
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
- toplevel = gtk_widget_get_toplevel (widget);
+ toplevel = _gtk_widget_get_toplevel (widget);
if (GTK_IS_WINDOW (toplevel))
return widget == gtk_window_get_focus (GTK_WINDOW (toplevel));
widget->priv->has_default = has_default;
- context = gtk_widget_get_style_context (widget);
+ context = _gtk_widget_get_style_context (widget);
if (has_default)
gtk_style_context_add_class (context, GTK_STYLE_CLASS_DEFAULT);
g_return_if_fail (GTK_IS_WIDGET (widget));
g_return_if_fail (gtk_widget_get_can_default (widget));
- window = gtk_widget_get_toplevel (widget);
+ window = _gtk_widget_get_toplevel (widget);
- if (window && gtk_widget_is_toplevel (window))
+ if (window && _gtk_widget_is_toplevel (window))
gtk_window_set_default (GTK_WINDOW (window), widget);
else
g_warning (G_STRLOC ": widget not within a GtkWindow");
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
g_return_val_if_fail (GDK_IS_DEVICE (device), FALSE);
- if (!gtk_widget_get_realized (widget))
+ if (!_gtk_widget_get_realized (widget))
return TRUE;
- toplevel = gtk_widget_get_toplevel (widget);
+ toplevel = _gtk_widget_get_toplevel (widget);
if (GTK_IS_WINDOW (toplevel))
group = gtk_window_get_group (GTK_WINDOW (toplevel));
{
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
- return (gtk_widget_get_visible (widget) &&
- gtk_widget_get_mapped (widget));
+ return (_gtk_widget_get_visible (widget) &&
+ _gtk_widget_get_mapped (widget));
}
/**
g_warning ("Can't set a parent on widget which has a parent\n");
return;
}
- if (gtk_widget_is_toplevel (widget))
+ if (_gtk_widget_is_toplevel (widget))
{
g_warning ("Can't set a parent on a toplevel widget\n");
return;
gtk_css_node_set_parent (widget->priv->cssnode, parent->priv->cssnode);
if (priv->context)
gtk_style_context_set_parent (priv->context,
- gtk_widget_get_style_context (parent));
+ _gtk_widget_get_style_context (parent));
_gtk_widget_update_parent_muxer (widget);
/* Enforce realized/mapped invariants
*/
- if (gtk_widget_get_realized (priv->parent))
+ if (_gtk_widget_get_realized (priv->parent))
gtk_widget_realize (widget);
- if (gtk_widget_get_visible (priv->parent) &&
- gtk_widget_get_visible (widget))
+ if (_gtk_widget_get_visible (priv->parent) &&
+ _gtk_widget_get_visible (widget))
{
- if (gtk_widget_get_child_visible (widget) &&
- gtk_widget_get_mapped (priv->parent))
+ if (_gtk_widget_get_child_visible (widget) &&
+ _gtk_widget_get_mapped (priv->parent))
gtk_widget_map (widget);
gtk_widget_queue_resize (widget);
*
* We can't change a parent to need to expand unless we're visible.
*/
- if (gtk_widget_get_visible (widget) &&
+ if (_gtk_widget_get_visible (widget) &&
(priv->need_compute_expand ||
priv->computed_hexpand ||
priv->computed_vexpand))
style,
(GDestroyNotify) g_object_unref);
- context = gtk_widget_get_style_context (widget);
+ context = _gtk_widget_get_style_context (widget);
gtk_style_context_add_provider (context,
GTK_STYLE_PROVIDER (style),
{
GtkWidgetPrivate *priv = widget->priv;
HierarchyChangedInfo *info = client_data;
- gboolean new_anchored = gtk_widget_is_toplevel (widget) ||
+ gboolean new_anchored = _gtk_widget_is_toplevel (widget) ||
(priv->parent && priv->parent->priv->anchored);
if (priv->anchored != new_anchored)
info.previous_toplevel = previous_toplevel;
info.previous_screen = previous_toplevel ? gtk_widget_get_screen (previous_toplevel) : NULL;
- if (gtk_widget_is_toplevel (widget) ||
+ if (_gtk_widget_is_toplevel (widget) ||
(priv->parent && priv->parent->priv->anchored))
info.new_screen = gtk_widget_get_screen (widget);
else
GtkStyleContext *style_context;
GdkScreen *screen;
- style_context = gtk_widget_get_style_context (widget);
+ style_context = _gtk_widget_get_style_context (widget);
gtk_style_context_get (style_context,
gtk_widget_get_state_flags (widget),
"font", &font_desc,
g_return_val_if_fail (stock_id != NULL, NULL);
g_return_val_if_fail (size > GTK_ICON_SIZE_INVALID || size == -1, NULL);
- context = gtk_widget_get_style_context (widget);
+ context = _gtk_widget_get_style_context (widget);
G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
icon_set = gtk_style_context_lookup_icon_set (context, stock_id);
GtkWidgetPrivate *priv;
g_return_if_fail (GTK_IS_WIDGET (widget));
- g_return_if_fail (!gtk_widget_is_toplevel (widget));
+ g_return_if_fail (!_gtk_widget_is_toplevel (widget));
priv = widget->priv;
priv->child_visible = FALSE;
- toplevel = gtk_widget_get_toplevel (widget);
- if (toplevel != widget && gtk_widget_is_toplevel (toplevel))
+ toplevel = _gtk_widget_get_toplevel (widget);
+ if (toplevel != widget && _gtk_widget_is_toplevel (toplevel))
_gtk_window_unset_focus_and_default (GTK_WINDOW (toplevel), widget);
}
- if (priv->parent && gtk_widget_get_realized (priv->parent))
+ if (priv->parent && _gtk_widget_get_realized (priv->parent))
{
- if (gtk_widget_get_mapped (priv->parent) &&
+ if (_gtk_widget_get_mapped (priv->parent) &&
priv->child_visible &&
- gtk_widget_get_visible (widget))
+ _gtk_widget_get_visible (widget))
gtk_widget_map (widget);
else
gtk_widget_unmap (widget);
{
GtkWidget *toplevel;
- toplevel = gtk_widget_get_toplevel (widget);
+ toplevel = _gtk_widget_get_toplevel (widget);
- if (gtk_widget_is_toplevel (toplevel))
+ if (_gtk_widget_is_toplevel (toplevel))
{
if (GTK_IS_WINDOW (toplevel))
return gtk_window_get_screen (GTK_WINDOW (toplevel));
g_return_val_if_fail (GTK_IS_WIDGET (widget), 1);
- if (gtk_widget_get_realized (widget))
+ if (_gtk_widget_get_realized (widget))
return gdk_window_get_scale_factor (gtk_widget_get_window (widget));
- toplevel = gtk_widget_get_toplevel (widget);
+ toplevel = _gtk_widget_get_toplevel (widget);
if (toplevel && toplevel != widget)
return gtk_widget_get_scale_factor (toplevel);
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
- if (!gtk_widget_get_visible (widget) ||
+ if (!_gtk_widget_get_visible (widget) ||
!gtk_widget_is_sensitive (widget))
return FALSE;
changed = TRUE;
}
- if (gtk_widget_get_visible (widget) && changed)
+ if (_gtk_widget_get_visible (widget) && changed)
{
if ((flags & GTK_QUEUE_RESIZE_INVALIDATE_ONLY) == 0)
gtk_widget_queue_resize (widget);
gint e;
g_return_if_fail (GTK_IS_WIDGET (widget));
- g_return_if_fail (!gtk_widget_get_realized (widget));
+ g_return_if_fail (!_gtk_widget_get_realized (widget));
e = GPOINTER_TO_INT (g_object_get_qdata (G_OBJECT (widget), quark_event_mask));
if (e != events)
g_return_if_fail (GTK_IS_WIDGET (widget));
g_return_if_fail (GDK_IS_DEVICE (device));
- g_return_if_fail (!gtk_widget_get_realized (widget));
+ g_return_if_fail (!_gtk_widget_get_realized (widget));
device_events = g_object_get_qdata (G_OBJECT (widget), quark_device_event_mask);
g_object_set_qdata_full (G_OBJECT (widget), quark_enabled_devices,
enabled_devices, (GDestroyNotify) g_list_free);;
- if (gtk_widget_get_realized (widget))
+ if (_gtk_widget_get_realized (widget))
gtk_widget_set_device_enabled_internal (widget, device, TRUE, enabled);
}
g_object_set_qdata (G_OBJECT (widget), quark_event_mask,
GINT_TO_POINTER (old_events | events));
- if (gtk_widget_get_realized (widget))
+ if (_gtk_widget_get_realized (widget))
{
gtk_widget_add_events_internal (widget, NULL, events);
gtk_widget_update_devices_mask (widget, FALSE);
g_hash_table_insert (device_events, device,
GUINT_TO_POINTER (old_events | events));
- if (gtk_widget_get_realized (widget))
+ if (_gtk_widget_get_realized (widget))
gtk_widget_add_events_internal (widget, device, events);
g_object_notify_by_pspec (G_OBJECT (widget), widget_props[PROP_EVENTS]);
if (y)
*y = -1;
- if (gtk_widget_get_realized (widget))
+ if (_gtk_widget_get_realized (widget))
{
gdk_window_get_device_position (priv->window,
gdk_device_manager_get_client_pointer (
if (priv->parent)
gtk_container_remove (GTK_CONTAINER (priv->parent), widget);
- else if (gtk_widget_get_visible (widget))
+ else if (_gtk_widget_get_visible (widget))
gtk_widget_hide (widget);
priv->visible = FALSE;
- if (gtk_widget_get_realized (widget))
+ if (_gtk_widget_get_realized (widget))
gtk_widget_unrealize (widget);
if (!priv->in_destruction)
{
GtkWidgetPrivate *priv = widget->priv;
- g_assert (gtk_widget_get_realized (widget));
+ g_assert (_gtk_widget_get_realized (widget));
- if (!gtk_widget_get_mapped (widget))
+ if (!_gtk_widget_get_mapped (widget))
{
gtk_widget_set_mapped (widget, TRUE);
{
GtkWidgetPrivate *priv = widget->priv;
- if (gtk_widget_get_mapped (widget))
+ if (_gtk_widget_get_mapped (widget))
{
gtk_widget_set_mapped (widget, FALSE);
display = gtk_widget_get_display (widget);
device_manager = gdk_display_get_device_manager (display);
- if (!gtk_widget_get_mapped (widget))
+ if (!_gtk_widget_get_mapped (widget))
return NULL;
list_devices (widget, device_manager, GDK_DEVICE_TYPE_MASTER, &result);
{
GtkWidget *window;
- window = gtk_widget_get_toplevel (widget);
+ window = _gtk_widget_get_toplevel (widget);
- if (window && gtk_widget_is_toplevel (window))
+ if (window && _gtk_widget_is_toplevel (window))
gtk_window_set_focus (GTK_WINDOW (window), NULL);
}
if (!gtk_widget_is_sensitive (widget) && gtk_widget_has_grab (widget))
gtk_grab_remove (widget);
- gtk_style_context_set_state (gtk_widget_get_style_context (widget), new_flags);
+ gtk_style_context_set_state (_gtk_widget_get_style_context (widget), new_flags);
g_signal_emit (widget, widget_signals[STATE_CHANGED], 0, old_state);
g_signal_emit (widget, widget_signals[STATE_FLAGS_CHANGED], 0, old_flags);
GtkStyleContext *context;
const GValue *peek_value;
- context = gtk_widget_get_style_context (widget);
+ context = _gtk_widget_get_style_context (widget);
peek_value = _gtk_style_context_peek_style_property (context,
G_OBJECT_TYPE (widget),
g_return_if_fail (GTK_IS_WIDGET (widget));
g_object_ref (widget);
- context = gtk_widget_get_style_context (widget);
+ context = _gtk_widget_get_style_context (widget);
name = first_property_name;
while (name)
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
/* We never make a widget expand if not even showing. */
- if (!gtk_widget_get_visible (widget))
+ if (!_gtk_widget_get_visible (widget))
return FALSE;
gtk_widget_update_computed_expand (widget);
accel_data = (AccelGroupParserData*)user_data;
g_assert (accel_data->object);
- toplevel = gtk_widget_get_toplevel (GTK_WIDGET (accel_data->object));
+ toplevel = _gtk_widget_get_toplevel (GTK_WIDGET (accel_data->object));
_gtk_widget_buildable_finish_accelerator (GTK_WIDGET (buildable), toplevel, user_data);
}
GtkStyleContext *context;
GSList *l;
- context = gtk_widget_get_style_context (GTK_WIDGET (buildable));
+ context = _gtk_widget_get_style_context (GTK_WIDGET (buildable));
for (l = style_data->classes; l; l = l->next)
gtk_style_context_add_class (context, (const gchar *)l->data);
if (priv_has_tooltip)
{
- if (gtk_widget_get_realized (widget) && !gtk_widget_get_has_window (widget))
+ if (_gtk_widget_get_realized (widget) && !gtk_widget_get_has_window (widget))
gdk_window_set_events (priv->window,
gdk_window_get_events (priv->window) |
GDK_LEAVE_NOTIFY_MASK |
has_tooltip = (custom_window != NULL || tooltip_markup != NULL);
gtk_widget_real_set_has_tooltip (widget, has_tooltip, FALSE);
- if (has_tooltip && gtk_widget_get_visible (widget))
+ if (has_tooltip && _gtk_widget_get_visible (widget))
gtk_widget_queue_tooltip_query (widget);
}
GtkWidgetPrivate *priv;
g_return_if_fail (GTK_IS_WIDGET (widget));
- g_return_if_fail (gtk_widget_get_visible (widget) || gtk_widget_is_toplevel (widget));
+ g_return_if_fail (_gtk_widget_get_visible (widget) || _gtk_widget_is_toplevel (widget));
g_return_if_fail (clip != NULL);
priv = widget->priv;
while (parent)
{
depth++;
- parent = gtk_widget_get_parent (parent);
+ parent = _gtk_widget_get_parent (parent);
}
name = g_type_name (G_OBJECT_TYPE (G_OBJECT (widget)));
GtkAllocation widget_clip;
if (!gtk_widget_is_visible (widget) ||
- !gtk_widget_get_child_visible (widget))
+ !_gtk_widget_get_child_visible (widget))
return;
gtk_widget_get_clip (widget, &widget_clip);
GtkAllocation clip, allocation;
GtkBorder extents;
- context = gtk_widget_get_style_context (widget);
+ context = _gtk_widget_get_style_context (widget);
gtk_widget_get_allocation (widget, &allocation);
GtkWidgetPrivate *priv;
g_return_if_fail (GTK_IS_WIDGET (widget));
- g_return_if_fail (gtk_widget_get_visible (widget) || gtk_widget_is_toplevel (widget));
+ g_return_if_fail (_gtk_widget_get_visible (widget) || _gtk_widget_is_toplevel (widget));
g_return_if_fail (allocation != NULL);
priv = widget->priv;
priv = widget->priv;
priv->multidevice = (support_multidevice == TRUE);
- if (gtk_widget_get_realized (widget))
+ if (_gtk_widget_get_realized (widget))
gdk_window_set_support_multidevice (priv->window, support_multidevice);
}
alpha = priv->user_alpha;
- context = gtk_widget_get_style_context (widget);
+ context = _gtk_widget_get_style_context (widget);
opacity =
_gtk_css_number_value_get (_gtk_style_context_peek_property (context,
GTK_CSS_PROPERTY_OPACITY),
priv->alpha = alpha;
- if (gtk_widget_get_realized (widget))
+ if (_gtk_widget_get_realized (widget))
{
- if (gtk_widget_is_toplevel (widget) &&
+ if (_gtk_widget_is_toplevel (widget) &&
gtk_widget_get_visual (widget) != gdk_screen_get_rgba_visual (gtk_widget_get_screen (widget)))
gdk_window_set_opacity (priv->window, priv->alpha / 255.0);
void
_gtk_widget_style_context_invalidated (GtkWidget *widget)
{
- if (gtk_widget_get_realized (widget))
+ if (_gtk_widget_get_realized (widget))
g_signal_emit (widget, widget_signals[STYLE_UPDATED], 0);
else
{
g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
priv = widget->priv;
-
+
if (G_UNLIKELY (priv->context == NULL))
{
GdkScreen *screen;
if (priv->parent)
gtk_style_context_set_parent (priv->context,
- gtk_widget_get_style_context (priv->parent));
+ _gtk_widget_get_style_context (priv->parent));
}
return widget->priv->context;
else if (GTK_IS_POPOVER (widget))
parent = gtk_popover_get_relative_to (GTK_POPOVER (widget));
else
- parent = gtk_widget_get_parent (widget);
+ parent = _gtk_widget_get_parent (widget);
if (parent)
return _gtk_widget_get_action_muxer (parent, create);
static void
_gtk_widget_update_evmask (GtkWidget *widget)
{
- if (gtk_widget_get_realized (widget))
+ if (_gtk_widget_get_realized (widget))
{
gint events = GPOINTER_TO_INT (g_object_get_qdata (G_OBJECT (widget),
quark_event_mask));
GTK_EVENT_SEQUENCE_DENIED,
NULL);
- event_widget = gtk_widget_get_parent (event_widget);
+ event_widget = _gtk_widget_get_parent (event_widget);
}
}
#include "gtkcsstypesprivate.h"
#include "gtkwidget.h"
+#include "gtkcontainer.h"
#include "gtkeventcontroller.h"
#include "gtkactionmuxer.h"
+#include "gtksizerequestcacheprivate.h"
G_BEGIN_DECLS
+#define GTK_STATE_FLAGS_BITS 12
+
+struct _GtkWidgetPrivate
+{
+ /* The state of the widget. Needs to be able to hold all GtkStateFlags bits
+ * (defined in "gtkenums.h").
+ */
+ guint state_flags : GTK_STATE_FLAGS_BITS;
+
+ guint direction : 2;
+
+ guint in_destruction : 1;
+ guint toplevel : 1;
+ guint anchored : 1;
+ guint composite_child : 1;
+ guint no_window : 1;
+ guint realized : 1;
+ guint mapped : 1;
+ guint visible : 1;
+ guint sensitive : 1;
+ guint can_focus : 1;
+ guint has_focus : 1;
+ guint can_default : 1;
+ guint has_default : 1;
+ guint receives_default : 1;
+ guint has_grab : 1;
+ guint shadowed : 1;
+ guint style_update_pending : 1;
+ guint app_paintable : 1;
+ guint double_buffered : 1;
+ guint redraw_on_alloc : 1;
+ guint no_show_all : 1;
+ guint child_visible : 1;
+ guint multidevice : 1;
+ guint has_shape_mask : 1;
+ guint in_reparent : 1;
+
+ /* Queue-resize related flags */
+ guint alloc_needed : 1;
+
+ /* Expand-related flags */
+ guint need_compute_expand : 1; /* Need to recompute computed_[hv]_expand */
+ guint computed_hexpand : 1; /* computed results (composite of child flags) */
+ guint computed_vexpand : 1;
+ guint hexpand : 1; /* application-forced expand */
+ guint vexpand : 1;
+ guint hexpand_set : 1; /* whether to use application-forced */
+ guint vexpand_set : 1; /* instead of computing from children */
+
+ /* SizeGroup related flags */
+ guint have_size_groups : 1;
+
+ guint8 alpha;
+ guint8 user_alpha;
+
+ /* The widget's name. If the widget does not have a name
+ * (the name is NULL), then its name (as returned by
+ * "gtk_widget_get_name") is its class's name.
+ * Among other things, the widget name is used to determine
+ * the style to use for a widget.
+ */
+ gchar *name;
+
+ /* The list of attached windows to this widget.
+ * We keep a list in order to call reset_style to all of them,
+ * recursively. */
+ GList *attached_windows;
+
+ /* The style for the widget. The style contains the
+ * colors the widget should be drawn in for each state
+ * along with graphics contexts used to draw with and
+ * the font to use for text.
+ */
+ GtkStyle *style;
+ GtkCssNode *cssnode;
+ GtkStyleContext *context;
+
+ /* Widget's path for styling */
+ GtkWidgetPath *path;
+
+ /* The widget's allocated size */
+ GtkAllocation allocation;
+ gint allocated_baseline;
+ GtkAllocation clip;
+
+ /* The widget's requested sizes */
+ SizeRequestCache requests;
+
+ /* actions attached to this or any parent widget */
+ GtkActionMuxer *muxer;
+
+ /* The widget's window or its parent window if it does
+ * not have a window. (Which will be indicated by the
+ * no_window field being set).
+ */
+ GdkWindow *window;
+ GList *registered_windows;
+
+ /* The widget's parent */
+ GtkWidget *parent;
+
+ /* Animations and other things to update on clock ticks */
+ GList *tick_callbacks;
+ guint clock_tick_id;
+
+ /* A hash by GType key, containing hash tables by widget name
+ */
+ GHashTable *auto_children;
+
+#ifdef G_ENABLE_DEBUG
+ /* Number of gtk_widget_push_verify_invariants () */
+ guint verifying_invariants_count;
+#endif /* G_ENABLE_DEBUG */
+
+ GList *event_controllers;
+
+ cairo_font_options_t *font_options;
+ PangoFontMap *font_map;
+};
+
GtkCssNode * gtk_widget_get_css_node (GtkWidget *widget);
void _gtk_widget_set_visible_flag (GtkWidget *widget,
gboolean visible);
gboolean gtk_widget_has_size_request (GtkWidget *widget);
+/* inline getters */
+
+static inline GtkWidget *
+_gtk_widget_get_parent (GtkWidget *widget)
+{
+ return widget->priv->parent;
+}
+
+static inline gboolean
+_gtk_widget_get_visible (GtkWidget *widget)
+{
+ return widget->priv->visible;
+}
+
+static inline gboolean
+_gtk_widget_get_child_visible (GtkWidget *widget)
+{
+ return widget->priv->child_visible;
+}
+
+static inline gboolean
+_gtk_widget_get_mapped (GtkWidget *widget)
+{
+ return widget->priv->mapped;
+}
+
+static inline gboolean
+_gtk_widget_get_realized (GtkWidget *widget)
+{
+ return widget->priv->realized;
+}
+
+static inline gboolean
+_gtk_widget_is_toplevel (GtkWidget *widget)
+{
+ return widget->priv->toplevel;
+}
+
+static inline GtkWidget *
+_gtk_widget_get_toplevel (GtkWidget *widget)
+{
+ while (widget->priv->parent)
+ widget = widget->priv->parent;
+
+ return widget;
+}
+
+static inline GtkStyleContext *
+_gtk_widget_get_style_context (GtkWidget *widget)
+{
+ if (G_LIKELY (widget->priv->context))
+ return widget->priv->context;
+
+ return gtk_widget_get_style_context (widget);
+}
+
G_END_DECLS
#endif /* __GTK_WIDGET_PRIVATE_H__ */
void
gtk_window_close (GtkWindow *window)
{
- if (!gtk_widget_get_realized (GTK_WIDGET (window)))
+ if (!_gtk_widget_get_realized (GTK_WIDGET (window)))
return;
window->priv->delete_event_handler = gdk_threads_add_idle (send_delete_event, window);
popover->unmap_id = 0;
}
- if (popover->widget && gtk_widget_get_parent (popover->widget))
+ if (popover->widget && _gtk_widget_get_parent (popover->widget))
gtk_widget_unparent (popover->widget);
if (popover->window)
if (new_title == NULL)
new_title = "";
- if (gtk_widget_get_realized (widget))
+ if (_gtk_widget_get_realized (widget))
gdk_window_set_title (gtk_widget_get_window (widget), new_title);
if (update_titlebar && GTK_IS_HEADER_BAR (priv->title_box))
g_free (priv->wmclass_class);
priv->wmclass_class = g_strdup (wmclass_class);
- if (gtk_widget_get_realized (GTK_WIDGET (window)))
+ if (_gtk_widget_get_realized (GTK_WIDGET (window)))
g_warning ("gtk_window_set_wmclass: shouldn't set wmclass after window is realized!\n");
}
g_free (priv->wm_role);
priv->wm_role = new_role;
- if (gtk_widget_get_realized (widget))
+ if (_gtk_widget_get_realized (widget))
gdk_window_set_role (gtk_widget_get_window (widget), priv->wm_role);
g_object_notify_by_pspec (G_OBJECT (window), window_props[PROP_ROLE]);
g_free (priv->startup_id);
priv->startup_id = g_strdup (startup_id);
- if (gtk_widget_get_realized (widget))
+ if (_gtk_widget_get_realized (widget))
{
GdkWindow *gdk_window;
guint32 timestamp = extract_time_from_startup_id (priv->startup_id);
GtkWidget *widget = priv->focus_widget;
if (widget)
{
- while ((parent = gtk_widget_get_parent (widget)))
+ while ((parent = _gtk_widget_get_parent (widget)))
{
widget = parent;
gtk_container_set_focus_child (GTK_CONTAINER (widget), NULL);
widget = GTK_WIDGET (window);
/* adjust desired modality state */
- if (gtk_widget_get_realized (widget))
+ if (_gtk_widget_get_realized (widget))
gdk_window_set_modal_hint (gtk_widget_get_window (widget), priv->modal);
if (gtk_widget_get_visible (widget))
gtk_window_transient_parent_realized (GtkWidget *parent,
GtkWidget *window)
{
- if (gtk_widget_get_realized (window))
+ if (_gtk_widget_get_realized (window))
gdk_window_set_transient_for (gtk_widget_get_window (window),
gtk_widget_get_window (parent));
}
gtk_window_transient_parent_unrealized (GtkWidget *parent,
GtkWidget *window)
{
- if (gtk_widget_get_realized (window))
+ if (_gtk_widget_get_realized (window))
gdk_property_delete (gtk_widget_get_window (window),
gdk_atom_intern_static_string ("WM_TRANSIENT_FOR"));
}
if (priv->transient_parent)
{
- if (gtk_widget_get_realized (GTK_WIDGET (window)) &&
- gtk_widget_get_realized (GTK_WIDGET (priv->transient_parent)) &&
- (!parent || !gtk_widget_get_realized (GTK_WIDGET (parent))))
+ if (_gtk_widget_get_realized (GTK_WIDGET (window)) &&
+ _gtk_widget_get_realized (GTK_WIDGET (priv->transient_parent)) &&
+ (!parent || !_gtk_widget_get_realized (GTK_WIDGET (parent))))
gtk_window_transient_parent_unrealized (GTK_WIDGET (priv->transient_parent),
GTK_WIDGET (window));
if (priv->destroy_with_parent)
connect_parent_destroyed (window);
- if (gtk_widget_get_realized (GTK_WIDGET (window)) &&
- gtk_widget_get_realized (GTK_WIDGET (parent)))
+ if (_gtk_widget_get_realized (GTK_WIDGET (window)) &&
+ _gtk_widget_get_realized (GTK_WIDGET (parent)))
gtk_window_transient_parent_realized (GTK_WIDGET (parent),
GTK_WIDGET (window));
if (priv->skips_taskbar != setting)
{
priv->skips_taskbar = setting;
- if (gtk_widget_get_realized (GTK_WIDGET (window)))
+ if (_gtk_widget_get_realized (GTK_WIDGET (window)))
gdk_window_set_skip_taskbar_hint (gtk_widget_get_window (GTK_WIDGET (window)),
priv->skips_taskbar);
g_object_notify_by_pspec (G_OBJECT (window), window_props[PROP_SKIP_TASKBAR_HINT]);
if (priv->skips_pager != setting)
{
priv->skips_pager = setting;
- if (gtk_widget_get_realized (GTK_WIDGET (window)))
+ if (_gtk_widget_get_realized (GTK_WIDGET (window)))
gdk_window_set_skip_pager_hint (gtk_widget_get_window (GTK_WIDGET (window)),
priv->skips_pager);
g_object_notify_by_pspec (G_OBJECT (window), window_props[PROP_SKIP_PAGER_HINT]);
if (priv->urgent != setting)
{
priv->urgent = setting;
- if (gtk_widget_get_realized (GTK_WIDGET (window)))
+ if (_gtk_widget_get_realized (GTK_WIDGET (window)))
gdk_window_set_urgency_hint (gtk_widget_get_window (GTK_WIDGET (window)),
priv->urgent);
g_object_notify_by_pspec (G_OBJECT (window), window_props[PROP_URGENCY_HINT]);
if (priv->accept_focus != setting)
{
priv->accept_focus = setting;
- if (gtk_widget_get_realized (GTK_WIDGET (window)))
+ if (_gtk_widget_get_realized (GTK_WIDGET (window)))
gdk_window_set_accept_focus (gtk_widget_get_window (GTK_WIDGET (window)),
priv->accept_focus);
g_object_notify_by_pspec (G_OBJECT (window), window_props[PROP_ACCEPT_FOCUS]);
if (priv->focus_on_map != setting)
{
priv->focus_on_map = setting;
- if (gtk_widget_get_realized (GTK_WIDGET (window)))
+ if (_gtk_widget_get_realized (GTK_WIDGET (window)))
gdk_window_set_focus_on_map (gtk_widget_get_window (GTK_WIDGET (window)),
priv->focus_on_map);
g_object_notify_by_pspec (G_OBJECT (window), window_props[PROP_FOCUS_ON_MAP]);
if ((!priv->title_box && titlebar) || (priv->title_box && !titlebar))
{
was_mapped = gtk_widget_get_mapped (widget);
- if (gtk_widget_get_realized (widget))
+ if (_gtk_widget_get_realized (widget))
{
g_warning ("gtk_window_set_titlebar() called on a realized window");
gtk_widget_unrealize (widget);
gtk_window_unrealize_icon (window);
- if (gtk_widget_get_realized (GTK_WIDGET (window)))
+ if (_gtk_widget_get_realized (GTK_WIDGET (window)))
gtk_window_realize_icon (window);
/* We could try to update our transient children, but I don't think
gtk_window_unrealize_icon (window);
- if (gtk_widget_get_realized (GTK_WIDGET (window)))
+ if (_gtk_widget_get_realized (GTK_WIDGET (window)))
gtk_window_realize_icon (window);
}
if (info && info->using_default_icon)
{
gtk_window_unrealize_icon (w);
- if (gtk_widget_get_realized (GTK_WIDGET (w)))
+ if (_gtk_widget_get_realized (GTK_WIDGET (w)))
gtk_window_realize_icon (w);
}
if (info && info->using_default_icon && info->using_themed_icon)
{
gtk_window_unrealize_icon (w);
- if (gtk_widget_get_realized (GTK_WIDGET (w)))
+ if (_gtk_widget_get_realized (GTK_WIDGET (w)))
gtk_window_realize_icon (w);
}
_gtk_widget_set_visible_flag (widget, TRUE);
- need_resize = _gtk_widget_get_alloc_needed (widget) || !gtk_widget_get_realized (widget);
+ need_resize = _gtk_widget_get_alloc_needed (widget) || !_gtk_widget_get_realized (widget);
gtk_css_node_validate (gtk_widget_get_css_node (widget));
/* Then we guarantee we have a realize */
was_realized = FALSE;
- if (!gtk_widget_get_realized (widget))
+ if (!_gtk_widget_get_realized (widget))
{
gtk_widget_realize (widget);
was_realized = TRUE;
GtkStyleContext *context;
gboolean is_opaque = FALSE;
- if (!gtk_widget_get_realized (widget))
+ if (!_gtk_widget_get_realized (widget))
return;
context = gtk_widget_get_style_context (widget);
_gtk_container_queue_resize (GTK_CONTAINER (widget));
- g_return_if_fail (!gtk_widget_get_realized (widget));
+ g_return_if_fail (!_gtk_widget_get_realized (widget));
}
if (priv->hardcoded_window)
}
if (priv->transient_parent &&
- gtk_widget_get_realized (GTK_WIDGET (priv->transient_parent)))
+ _gtk_widget_get_realized (GTK_WIDGET (priv->transient_parent)))
gdk_window_set_transient_for (gdk_window,
gtk_widget_get_window (GTK_WIDGET (priv->transient_parent)));
get_shadow_width (widget, &window_border);
- if (gtk_widget_get_realized (widget))
+ if (_gtk_widget_get_realized (widget))
update_realized_window_properties (window, &child_allocation, &window_border);
priv->title_height = 0;
priv->title_height;
}
- if (!gtk_widget_is_toplevel (widget) && gtk_widget_get_realized (widget))
+ if (!gtk_widget_is_toplevel (widget) && _gtk_widget_get_realized (widget))
{
gdk_window_move_resize (gtk_widget_get_window (widget),
allocation->x, allocation->y,
break;
}
- parent = gtk_widget_get_parent (focus);
+ parent = _gtk_widget_get_parent (focus);
if (parent)
g_object_ref (parent);
}
/* Wrapped off the end, clear the focus setting for the toplpevel */
- parent = gtk_widget_get_parent (priv->focus_widget);
+ parent = _gtk_widget_get_parent (priv->focus_widget);
while (parent)
{
gtk_container_set_focus_child (GTK_CONTAINER (parent), NULL);
- parent = gtk_widget_get_parent (parent);
+ parent = _gtk_widget_get_parent (parent);
}
gtk_window_set_focus (GTK_WINDOW (container), NULL);
g_object_ref (window);
g_object_ref (widget);
- parent = gtk_widget_get_parent (widget);
+ parent = _gtk_widget_get_parent (widget);
if (gtk_container_get_focus_child (GTK_CONTAINER (parent)) == widget)
{
child = priv->focus_widget;
while (child && child != widget)
- child = gtk_widget_get_parent (child);
+ child = _gtk_widget_get_parent (child);
if (child == widget)
gtk_window_set_focus (GTK_WINDOW (window), NULL);
child = priv->default_widget;
while (child && child != widget)
- child = gtk_widget_get_parent (child);
+ child = _gtk_widget_get_parent (child);
if (child == widget)
gtk_window_set_default (window, NULL);
if (was_mapped)
gtk_widget_unmap (widget);
- if (gtk_widget_get_realized (widget))
+ if (_gtk_widget_get_realized (widget))
gtk_widget_unrealize (widget);
gtk_window_free_key_hash (window);
g_return_if_fail (GTK_IS_WINDOW (window));
g_return_if_fail (GTK_IS_WIDGET (popover));
g_return_if_fail (GTK_IS_WIDGET (parent));
- g_return_if_fail (gtk_widget_get_parent (popover) == NULL);
+ g_return_if_fail (_gtk_widget_get_parent (popover) == NULL);
g_return_if_fail (gtk_widget_is_ancestor (parent, GTK_WIDGET (window)));
priv = window->priv;
data->clamp_allocation = !!clamp_allocation;
priv->popovers = g_list_prepend (priv->popovers, data);
- if (gtk_widget_get_realized (GTK_WIDGET (window)))
+ if (_gtk_widget_get_realized (GTK_WIDGET (window)))
popover_realize (popover, data, window);
gtk_widget_set_parent (popover, GTK_WIDGET (window));
popover_unmap (popover, data);
- if (gtk_widget_get_realized (GTK_WIDGET (window)))
+ if (_gtk_widget_get_realized (GTK_WIDGET (window)))
popover_unrealize (popover, data, window);
priv->popovers = g_list_remove (priv->popovers, data);
GtkWindowPrivate *priv = window->priv;
g_return_if_fail (GTK_IS_WINDOW (window));
- g_return_if_fail (!gtk_widget_get_realized (GTK_WIDGET (window)));
+ g_return_if_fail (!_gtk_widget_get_realized (GTK_WIDGET (window)));
priv->use_subsurface = use_subsurface;
}
GtkWindowPrivate *priv = window->priv;
g_return_if_fail (GTK_IS_WINDOW (window));
- g_return_if_fail (!gtk_widget_get_realized (GTK_WIDGET (window)));
+ g_return_if_fail (!_gtk_widget_get_realized (GTK_WIDGET (window)));
if (priv->hardcoded_window)
g_object_unref (priv->hardcoded_window);
projects / gtk4.git / commitdiff